home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / net / InetAddress.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  9.3 KB  |  499 lines
  1. package java.net;
  2.  
  3. import java.io.IOException;
  4. import java.io.ObjectStreamException;
  5. import java.io.Serializable;
  6. import java.net.InetAddress.Cache.Type;
  7. import java.security.AccessController;
  8. import java.security.PrivilegedActionException;
  9. import java.util.HashMap;
  10. import sun.net.spi.nameservice.NameService;
  11. import sun.net.util.IPAddressUtil;
  12. import sun.security.action.GetBooleanAction;
  13. import sun.security.action.GetPropertyAction;
  14. import sun.security.action.LoadLibraryAction;
  15.  
  16. public class InetAddress implements Serializable {
  17.    static final int IPv4 = 1;
  18.    static final int IPv6 = 2;
  19.    static transient boolean preferIPv6Address = false;
  20.    String hostName;
  21.    int address;
  22.    int family;
  23.    private static NameService nameService = null;
  24.    private transient String canonicalHostName = null;
  25.    private static final long serialVersionUID = 3286316764910316507L;
  26.    private static Cache addressCache;
  27.    private static Cache negativeCache;
  28.    private static boolean addressCacheInit;
  29.    static InetAddress[] unknown_array;
  30.    static InetAddressImpl impl;
  31.    private static HashMap lookupTable;
  32.  
  33.    InetAddress() {
  34.    }
  35.  
  36.    private Object readResolve() throws ObjectStreamException {
  37.       return new Inet4Address(this.hostName, this.address);
  38.    }
  39.  
  40.    public boolean isMulticastAddress() {
  41.       return false;
  42.    }
  43.  
  44.    public boolean isAnyLocalAddress() {
  45.       return false;
  46.    }
  47.  
  48.    public boolean isLoopbackAddress() {
  49.       return false;
  50.    }
  51.  
  52.    public boolean isLinkLocalAddress() {
  53.       return false;
  54.    }
  55.  
  56.    public boolean isSiteLocalAddress() {
  57.       return false;
  58.    }
  59.  
  60.    public boolean isMCGlobal() {
  61.       return false;
  62.    }
  63.  
  64.    public boolean isMCNodeLocal() {
  65.       return false;
  66.    }
  67.  
  68.    public boolean isMCLinkLocal() {
  69.       return false;
  70.    }
  71.  
  72.    public boolean isMCSiteLocal() {
  73.       return false;
  74.    }
  75.  
  76.    public boolean isMCOrgLocal() {
  77.       return false;
  78.    }
  79.  
  80.    public boolean isReachable(int var1) throws IOException {
  81.       return this.isReachable((NetworkInterface)null, 0, var1);
  82.    }
  83.  
  84.    public boolean isReachable(NetworkInterface var1, int var2, int var3) throws IOException {
  85.       if (var2 < 0) {
  86.          throw new IllegalArgumentException("ttl can't be negative");
  87.       } else if (var3 < 0) {
  88.          throw new IllegalArgumentException("timeout can't be negative");
  89.       } else {
  90.          return impl.isReachable(this, var3, var1, var2);
  91.       }
  92.    }
  93.  
  94.    public String getHostName() {
  95.       return this.getHostName(true);
  96.    }
  97.  
  98.    String getHostName(boolean var1) {
  99.       if (this.hostName == null) {
  100.          this.hostName = getHostFromNameService(this, var1);
  101.       }
  102.  
  103.       return this.hostName;
  104.    }
  105.  
  106.    public String getCanonicalHostName() {
  107.       if (this.canonicalHostName == null) {
  108.          this.canonicalHostName = getHostFromNameService(this, true);
  109.       }
  110.  
  111.       return this.canonicalHostName;
  112.    }
  113.  
  114.    private static String getHostFromNameService(InetAddress var0, boolean var1) {
  115.       String var2;
  116.       try {
  117.          var2 = nameService.getHostByAddr(var0.getAddress());
  118.          if (var1) {
  119.             SecurityManager var3 = System.getSecurityManager();
  120.             if (var3 != null) {
  121.                var3.checkConnect(var2, -1);
  122.             }
  123.          }
  124.  
  125.          InetAddress[] var9 = getAllByName0(var2, var1);
  126.          boolean var4 = false;
  127.          if (var9 != null) {
  128.             for(int var5 = 0; !var4 && var5 < var9.length; ++var5) {
  129.                var4 = var0.equals(var9[var5]);
  130.             }
  131.          }
  132.  
  133.          if (!var4) {
  134.             var2 = var0.getHostAddress();
  135.             return var2;
  136.          }
  137.       } catch (SecurityException var6) {
  138.          var2 = var0.getHostAddress();
  139.       } catch (UnknownHostException var7) {
  140.          var2 = var0.getHostAddress();
  141.       }
  142.  
  143.       return var2;
  144.    }
  145.  
  146.    public byte[] getAddress() {
  147.       return null;
  148.    }
  149.  
  150.    public String getHostAddress() {
  151.       return null;
  152.    }
  153.  
  154.    public int hashCode() {
  155.       return -1;
  156.    }
  157.  
  158.    public boolean equals(Object var1) {
  159.       return false;
  160.    }
  161.  
  162.    public String toString() {
  163.       return (this.hostName != null ? this.hostName : "") + "/" + this.getHostAddress();
  164.    }
  165.  
  166.    private static void cacheInitIfNeeded() {
  167.       assert Thread.holdsLock(addressCache);
  168.  
  169.       if (!addressCacheInit) {
  170.          unknown_array = new InetAddress[1];
  171.          unknown_array[0] = impl.anyLocalAddress();
  172.          addressCache.put(impl.anyLocalAddress().getHostName(), unknown_array);
  173.          addressCacheInit = true;
  174.       }
  175.    }
  176.  
  177.    private static void cacheAddress(String var0, Object var1, boolean var2) {
  178.       var0 = var0.toLowerCase();
  179.       synchronized(addressCache) {
  180.          cacheInitIfNeeded();
  181.          if (var2) {
  182.             addressCache.put(var0, var1);
  183.          } else {
  184.             negativeCache.put(var0, var1);
  185.          }
  186.  
  187.       }
  188.    }
  189.  
  190.    private static Object getCachedAddress(String var0) {
  191.       var0 = var0.toLowerCase();
  192.       synchronized(addressCache) {
  193.          cacheInitIfNeeded();
  194.          CacheEntry var2 = addressCache.get(var0);
  195.          if (var2 == null) {
  196.             var2 = negativeCache.get(var0);
  197.          }
  198.  
  199.          return var2 != null ? var2.address : null;
  200.       }
  201.    }
  202.  
  203.    public static InetAddress getByAddress(String var0, byte[] var1) throws UnknownHostException {
  204.       if (var0 != null && var0.length() > 0 && var0.charAt(0) == '[' && var0.charAt(var0.length() - 1) == ']') {
  205.          var0 = var0.substring(1, var0.length() - 1);
  206.       }
  207.  
  208.       if (var1 != null) {
  209.          if (var1.length == 4) {
  210.             return new Inet4Address(var0, var1);
  211.          }
  212.  
  213.          if (var1.length == 16) {
  214.             byte[] var2 = IPAddressUtil.convertFromIPv4MappedAddress(var1);
  215.             if (var2 != null) {
  216.                return new Inet4Address(var0, var2);
  217.             }
  218.  
  219.             return new Inet6Address(var0, var1);
  220.          }
  221.       }
  222.  
  223.       throw new UnknownHostException("addr is of illegal length");
  224.    }
  225.  
  226.    public static InetAddress getByName(String var0) throws UnknownHostException {
  227.       return getAllByName(var0)[0];
  228.    }
  229.  
  230.    public static InetAddress[] getAllByName(String var0) throws UnknownHostException {
  231.       if (var0 != null && var0.length() != 0) {
  232.          boolean var6 = false;
  233.          if (var0.charAt(0) == '[') {
  234.             if (var0.length() <= 2 || var0.charAt(var0.length() - 1) != ']') {
  235.                throw new UnknownHostException(var0);
  236.             }
  237.  
  238.             var0 = var0.substring(1, var0.length() - 1);
  239.             var6 = true;
  240.          }
  241.  
  242.          if (Character.digit(var0.charAt(0), 16) == -1 && var0.charAt(0) != ':') {
  243.             if (var6) {
  244.                throw new UnknownHostException("[" + var0 + "]");
  245.             }
  246.          } else {
  247.             Object var2 = null;
  248.             int var3 = -1;
  249.             String var4 = null;
  250.             byte[] var7 = IPAddressUtil.textToNumericFormatV4(var0);
  251.             if (var7 == null) {
  252.                int var5;
  253.                if ((var5 = var0.indexOf("%")) != -1) {
  254.                   var3 = checkNumericZone(var0);
  255.                   if (var3 == -1) {
  256.                      var4 = var0.substring(var5 + 1);
  257.                   }
  258.                }
  259.  
  260.                var7 = IPAddressUtil.textToNumericFormatV6(var0);
  261.             } else if (var6) {
  262.                throw new UnknownHostException("[" + var0 + "]");
  263.             }
  264.  
  265.             InetAddress[] var8 = new InetAddress[1];
  266.             if (var7 != null) {
  267.                if (var7.length == 4) {
  268.                   var8[0] = new Inet4Address((String)null, var7);
  269.                } else if (var4 != null) {
  270.                   var8[0] = new Inet6Address((String)null, var7, var4);
  271.                } else {
  272.                   var8[0] = new Inet6Address((String)null, var7, var3);
  273.                }
  274.  
  275.                return var8;
  276.             }
  277.          }
  278.  
  279.          return getAllByName0(var0);
  280.       } else {
  281.          InetAddress[] var1 = new InetAddress[]{impl.loopbackAddress()};
  282.          return var1;
  283.       }
  284.    }
  285.  
  286.    private static int checkNumericZone(String var0) throws UnknownHostException {
  287.       int var1 = var0.indexOf(37);
  288.       int var2 = var0.length();
  289.       int var4 = 0;
  290.       if (var1 == -1) {
  291.          return -1;
  292.       } else {
  293.          for(int var5 = var1 + 1; var5 < var2; ++var5) {
  294.             char var6 = var0.charAt(var5);
  295.             if (var6 == ']') {
  296.                if (var5 == var1 + 1) {
  297.                   return -1;
  298.                }
  299.                break;
  300.             }
  301.  
  302.             int var3;
  303.             if ((var3 = Character.digit(var6, 10)) < 0) {
  304.                return -1;
  305.             }
  306.  
  307.             var4 = var4 * 10 + var3;
  308.          }
  309.  
  310.          return var4;
  311.       }
  312.    }
  313.  
  314.    private static InetAddress[] getAllByName0(String var0) throws UnknownHostException {
  315.       return getAllByName0(var0, true);
  316.    }
  317.  
  318.    static InetAddress[] getAllByName0(String var0, boolean var1) throws UnknownHostException {
  319.       Object var2 = null;
  320.       Object var3 = null;
  321.       if (var1) {
  322.          SecurityManager var4 = System.getSecurityManager();
  323.          if (var4 != null) {
  324.             var4.checkConnect(var0, -1);
  325.          }
  326.       }
  327.  
  328.       var2 = getCachedAddress(var0);
  329.       if (var2 == null) {
  330.          var2 = getAddressFromNameService(var0);
  331.       }
  332.  
  333.       if (var2 == unknown_array) {
  334.          throw new UnknownHostException(var0);
  335.       } else {
  336.          var3 = ((InetAddress[])((InetAddress[])var2)).clone();
  337.          return (InetAddress[])var3;
  338.       }
  339.    }
  340.  
  341.    private static Object getAddressFromNameService(String var0) throws UnknownHostException {
  342.       Object var1 = null;
  343.       boolean var2 = false;
  344.       if ((var1 = checkLookupTable(var0)) == null) {
  345.          try {
  346.             var1 = nameService.lookupAllHostAddr(var0);
  347.             var2 = true;
  348.          } catch (UnknownHostException var8) {
  349.             if (!var0.equalsIgnoreCase("localhost")) {
  350.                var1 = unknown_array;
  351.                var2 = false;
  352.                throw var8;
  353.             }
  354.  
  355.             InetAddress[] var4 = new InetAddress[]{impl.loopbackAddress()};
  356.             var1 = var4;
  357.             var2 = true;
  358.          } finally {
  359.             cacheAddress(var0, var1, var2);
  360.             updateLookupTable(var0);
  361.          }
  362.       }
  363.  
  364.       return var1;
  365.    }
  366.  
  367.    private static Object checkLookupTable(String var0) {
  368.       Object var1 = null;
  369.       synchronized(lookupTable) {
  370.          if (!lookupTable.containsKey(var0)) {
  371.             lookupTable.put(var0, (Object)null);
  372.             return var1;
  373.          }
  374.  
  375.          while(lookupTable.containsKey(var0)) {
  376.             try {
  377.                lookupTable.wait();
  378.             } catch (InterruptedException var7) {
  379.             }
  380.          }
  381.       }
  382.  
  383.       var1 = getCachedAddress(var0);
  384.       if (var1 == null) {
  385.          synchronized(lookupTable) {
  386.             lookupTable.put(var0, (Object)null);
  387.          }
  388.       }
  389.  
  390.       return var1;
  391.    }
  392.  
  393.    private static void updateLookupTable(String var0) {
  394.       synchronized(lookupTable) {
  395.          lookupTable.remove(var0);
  396.          lookupTable.notifyAll();
  397.       }
  398.    }
  399.  
  400.    public static InetAddress getByAddress(byte[] var0) throws UnknownHostException {
  401.       return getByAddress((String)null, var0);
  402.    }
  403.  
  404.    public static InetAddress getLocalHost() throws UnknownHostException {
  405.       SecurityManager var0 = System.getSecurityManager();
  406.  
  407.       try {
  408.          String var1 = impl.getLocalHostName();
  409.          if (var0 != null) {
  410.             var0.checkConnect(var1, -1);
  411.          }
  412.  
  413.          if (var1.equals("localhost")) {
  414.             return impl.loopbackAddress();
  415.          } else {
  416.             InetAddress[] var2;
  417.             try {
  418.                var2 = (InetAddress[])getAddressFromNameService(var1);
  419.             } catch (UnknownHostException var4) {
  420.                throw new UnknownHostException(var1 + ": " + var4.getMessage());
  421.             }
  422.  
  423.             return var2[0];
  424.          }
  425.       } catch (SecurityException var5) {
  426.          return impl.loopbackAddress();
  427.       }
  428.    }
  429.  
  430.    private static native void init();
  431.  
  432.    static InetAddress anyLocalAddress() {
  433.       return impl.anyLocalAddress();
  434.    }
  435.  
  436.    static Object loadImpl(String var0) {
  437.       String var2 = (String)AccessController.doPrivileged(new GetPropertyAction("impl.prefix", ""));
  438.       Object var1 = null;
  439.  
  440.       try {
  441.          var1 = Class.forName("java.net." + var2 + var0).newInstance();
  442.       } catch (ClassNotFoundException var5) {
  443.          System.err.println("Class not found: java.net." + var2 + var0 + ":\ncheck impl.prefix property " + "in your properties file.");
  444.       } catch (InstantiationException var6) {
  445.          System.err.println("Could not instantiate: java.net." + var2 + var0 + ":\ncheck impl.prefix property " + "in your properties file.");
  446.       } catch (IllegalAccessException var7) {
  447.          System.err.println("Cannot access class: java.net." + var2 + var0 + ":\ncheck impl.prefix property " + "in your properties file.");
  448.       }
  449.  
  450.       if (var1 == null) {
  451.          try {
  452.             var1 = Class.forName(var0).newInstance();
  453.          } catch (Exception var4) {
  454.             throw new Error("System property impl.prefix incorrect");
  455.          }
  456.       }
  457.  
  458.       return var1;
  459.    }
  460.  
  461.    // $FF: synthetic method
  462.    static NameService access$002(NameService var0) {
  463.       nameService = var0;
  464.       return var0;
  465.    }
  466.  
  467.    static {
  468.       preferIPv6Address = (Boolean)AccessController.doPrivileged(new GetBooleanAction("java.net.preferIPv6Addresses"));
  469.       AccessController.doPrivileged(new LoadLibraryAction("net"));
  470.       init();
  471.       addressCache = new Cache(Type.Positive);
  472.       negativeCache = new Cache(Type.Negative);
  473.       addressCacheInit = false;
  474.       lookupTable = new HashMap();
  475.       new InetAddressImplFactory();
  476.       impl = InetAddressImplFactory.create();
  477.       Object var0 = null;
  478.       String var1 = "sun.net.spi.nameservice.provider.";
  479.       int var2 = 1;
  480.  
  481.       while(nameService == null) {
  482.          String var6 = (String)AccessController.doPrivileged(new GetPropertyAction(var1 + var2, "default"));
  483.          ++var2;
  484.          if (var6.equals("default")) {
  485.             nameService = new 1();
  486.             break;
  487.          }
  488.  
  489.          String var3 = var6;
  490.  
  491.          try {
  492.             AccessController.doPrivileged(new 2(var3));
  493.          } catch (PrivilegedActionException var5) {
  494.          }
  495.       }
  496.  
  497.    }
  498. }
  499.